{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "792ffe3e",
   "metadata": {},
   "outputs": [],
   "source": [
    "import argparse\n",
    "import os\n",
    "\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "from matplotlib import pyplot as plt\n",
    "\n",
    "from model import Pixel\n",
    "\n",
    "def parse_args():\n",
    "    # 解析输入参数\n",
    "    parser = argparse.ArgumentParser(\n",
    "        description='Tools for analyse battery consume',\n",
    "    )\n",
    "    parser.add_argument('--mode', default=\"A\")\n",
    "    parser.add_argument('--path', default=\"batteryStats/Pixel/Expriment/replay/v0.1\")\n",
    "    parser.add_argument('--brand', default=\"pixel\")\n",
    "    args = parser.parse_args()\n",
    "    return args\n",
    "\n",
    "def get_hardware_element(battery):\n",
    "    hardware = pd.DataFrame()\n",
    "    hardware[\"CPU\"] = [battery.cpu_count]\n",
    "    hardware['wifi_radio'] = [battery.radio_count]\n",
    "    hardware['cpu_runtime'] = [battery.cpu_runtime.total_seconds()]\n",
    "    hardware['rtc_alarm'] = [battery.qpnpRtcAlarm]\n",
    "    hardware['delivery_alarm'] = [battery.deliveryRtcAlarm]\n",
    "    hardware['drain'] = [battery.averageDrain]\n",
    "    return hardware\n",
    "\n",
    "def get_stategy_element():\n",
    "    pass\n",
    "\n",
    "# 使用箱型图的方法去除异常值\n",
    "def remove_outliers(data):\n",
    "    q1 = np.percentile(data, 25)\n",
    "    q3 = np.percentile(data, 75)\n",
    "    iqr = q3 - q1\n",
    "    lower_bound = q1 - 1.5 * iqr\n",
    "    upper_bound = q3 + 1.5 * iqr\n",
    "    filtered_data = [x for x in data if lower_bound <= x <= upper_bound]\n",
    "    return filtered_data\n",
    "\n",
    "def calculate_stats(arr):\n",
    "    mean = np.mean(arr)\n",
    "    std = np.std(arr)\n",
    "    median = np.median(arr)\n",
    "    return mean, std, median\n",
    "\n",
    "def print_stats(network_data,metrics):\n",
    "    for j in range(len(networks)):\n",
    "        align_drain = network_data.get(networks[j]).get(strategies_list[0]).get(metrics)\n",
    "        origin_drain = network_data.get(networks[j]).get(strategies_list[1]).get(metrics)\n",
    "        align_drain = remove_outliers(align_drain)\n",
    "        origin_drain = remove_outliers(origin_drain)\n",
    "        mean, std, median = calculate_stats(align_drain)\n",
    "        print(\"\\n\" + networks[j])\n",
    "        print(\"Align\")\n",
    "        print(f'平均值: {mean}')\n",
    "        print(f'标准差: {std}')\n",
    "        print(f'中位数: {median}')\n",
    "        origin_mean, origin_std, origin_median = calculate_stats(origin_drain)\n",
    "        print(\"Origin\")\n",
    "        m = -(origin_mean - mean) / origin_mean * 100\n",
    "        n = -(origin_std - std) / origin_std * 100\n",
    "        q = -(origin_median - median) / origin_median * 100\n",
    "        print(f'平均值: {origin_mean}')\n",
    "        print(f'标准差: {origin_std}')\n",
    "        print(f'中位数: {origin_median}')\n",
    "\n",
    "        print(f'\\n下降比例: {m}%')\n",
    "        print(f'下降比例: {n}%')\n",
    "        print(f'下降比例: {q}%')\n",
    "\n",
    "def plot_stategy_pic(network_data):\n",
    "    attri = [\"rtc_alarm\", \"drain\"]\n",
    "    # 创建一个2行2列的子图\n",
    "    fig, axs = plt.subplots(1, 2)\n",
    "    for i in range(len(attri)):\n",
    "        for j in range(len(networks)):\n",
    "            axs[i].boxplot([network_data.get(networks[j]).get(strategies_list[0]).get(attri[i]),\n",
    "                            network_data.get(networks[j]).get(strategies_list[1]).get(attri[i])], showmeans=True,\n",
    "                           meanline=True)\n",
    "            axs[i].set_xticklabels([strategies_list[0], strategies_list[1]])\n",
    "            axs[i].set_title(networks[j] + \" \" + attri[i])\n",
    "    # 调整子图之间的垂直间距\n",
    "    plt.subplots_adjust(hspace=0.5)\n",
    "    plt.figure(figsize=(8, 2))\n",
    "    # 显示图形\n",
    "    plt.show()\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "8b97f095",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "fullAlign\n",
      "device1_0921_1.txt: \n",
      "App wakeup alarm：468\n",
      "device1_0925_1.txt: \n",
      "App wakeup alarm：1597\n",
      "device4_0922_1.txt: \n",
      "App wakeup alarm：426\n",
      "device4_align_0927_1.txt: \n",
      "App wakeup alarm：380\n",
      "device4_align_0926_1.txt: \n",
      "App wakeup alarm：228\n",
      "device4_0921_2.txt: \n",
      "App wakeup alarm：169\n",
      "device1_align_0926_1.txt: \n",
      "App wakeup alarm：203\n",
      "device1_align_0927_1.txt: \n",
      "App wakeup alarm：391\n",
      "origin\n",
      "device1_origin_0926_1.txt: \n",
      "App wakeup alarm：391\n",
      "device4_0925_1.txt: \n",
      "App wakeup alarm：1598\n",
      "device1_0921_2.txt: \n",
      "App wakeup alarm：262\n",
      "device4_0921_1.txt: \n",
      "App wakeup alarm：498\n",
      "device1_0922_1.txt: \n",
      "App wakeup alarm：436\n",
      "device4_origin_0925_2.txt: \n",
      "App wakeup alarm：261\n",
      "device1_origin_0925_2.txt: \n",
      "App wakeup alarm：277\n",
      "device4_origin_0926_1.txt: \n",
      "App wakeup alarm：383\n"
     ]
    }
   ],
   "source": [
    "\n",
    "data_path = \"batteryStats/oppo/v0.3/pixel\"\n",
    "\n",
    "# 不同策略下的数据\n",
    "networks = [\"wifi\"]\n",
    "strategies_list = [\"fullAlign\", \"origin\"]\n",
    "network_data = {\"wifi\": {}}\n",
    "for n in networks:\n",
    "    tmp = {}\n",
    "    for s in strategies_list:\n",
    "        tmp[s] = {\"rtc_alarm\": [], \"drain\": [],\"cpu_time\":[],\"wifi_radio\":[],\"cpu_runtime\":[],\"wakelock\":[]}\n",
    "    network_data[n] = tmp\n",
    "\n",
    "stratgies = {\n",
    "    \"fullAlign\": {\"rtc_alarm\": [], \"drain\": []},\n",
    "    \"origin\": {\"rtc_alarm\": [], \"drain\": []}\n",
    "}\n",
    "all_attri_num = pd.DataFrame()\n",
    "# 可选参数flight 、 wifi 、lte\n",
    "for network_pattern in networks:\n",
    "    # fullAlign对应完整的预测模块，align对应部分预测模块，paper对应对比论文，origin对应原生\n",
    "    fullAlign_path = os.path.join(data_path, network_pattern, strategies_list[0])\n",
    "    origin_path = os.path.join(data_path, network_pattern, strategies_list[1])\n",
    "    # align_path = \"batteryStats/align\"\n",
    "    # origin_path = \"batteryStats/origin\"\n",
    "    strtegies_path = [fullAlign_path, origin_path]\n",
    "    for i in range(len(strategies_list)):\n",
    "        print(strategies_list[i])\n",
    "        for file_name in os.listdir(strtegies_path[i]):\n",
    "            print(file_name + \": \")\n",
    "            battery = Pixel(os.path.join(strtegies_path[i], file_name))\n",
    "            # 添加数据\n",
    "            network_data.get(network_pattern).get(strategies_list[i]).get(\"rtc_alarm\").append(battery.deliveryRtcAlarm)\n",
    "            network_data.get(network_pattern).get(strategies_list[i]).get(\"cpu_time\").append(battery.cpu_count)\n",
    "            network_data.get(network_pattern).get(strategies_list[i]).get(\"drain\").append(battery.averageDrain)\n",
    "            network_data.get(network_pattern).get(strategies_list[i]).get(\"wakelock\").append(battery.wakeup_reason)\n",
    "            network_data.get(network_pattern).get(strategies_list[i]).get(\"wifi_radio\").append(battery.radio_count)\n",
    "            network_data.get(network_pattern).get(strategies_list[i]).get(\"cpu_runtime\").append(battery.cpu_runtime.total_seconds())\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "f86baadf",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 800x200 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "wifi\n",
      "Align\n",
      "平均值: 582.0\n",
      "标准差: 39.319206502675\n",
      "中位数: 596.0\n",
      "Origin\n",
      "平均值: 587.625\n",
      "标准差: 297.6520357313217\n",
      "中位数: 538.5\n",
      "\n",
      "下降比例: -0.9572431397574984%\n",
      "下降比例: -86.79021078889349%\n",
      "下降比例: 10.677808727948005%\n"
     ]
    }
   ],
   "source": [
    "plot_stategy_pic(network_data)\n",
    "print_stats(network_data,\"cpu_time\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "7d017538",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "wifi\n",
      "Align\n",
      "平均值: 100.5\n",
      "标准差: 8.470537173048708\n",
      "中位数: 98.0\n",
      "Origin\n",
      "平均值: 132.71428571428572\n",
      "标准差: 12.825357535693394\n",
      "中位数: 131.0\n",
      "\n",
      "下降比例: -24.273412271259424%\n",
      "下降比例: -33.954767736689426%\n",
      "下降比例: -25.190839694656486%\n"
     ]
    }
   ],
   "source": [
    "print_stats(network_data,\"rtc_alarm\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "edcee1a1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "wifi\n",
      "Align\n",
      "平均值: 733.8571428571429\n",
      "标准差: 48.13798194900207\n",
      "中位数: 739.0\n",
      "Origin\n",
      "平均值: 772.0\n",
      "标准差: 386.91213472828684\n",
      "中位数: 700.5\n",
      "\n",
      "下降比例: -4.940784603997035%\n",
      "下降比例: -87.55842021269055%\n",
      "下降比例: 5.496074232690935%\n"
     ]
    }
   ],
   "source": [
    "print_stats(network_data,\"wakelock\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c5d7fa12",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.16"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
